#ifndef SUBFUNC_HPP_
#define SUBFUNC_HPP_

class SubProblem;
typedef SubProblem* SubProblemPt;

#include "Algorithm.hpp"

using namespace Ipopt;

class SubProblem : public TNLP {
public:
  /** default constructor */
  SubProblem(AlgorithmRef parent, Index procIndex, Index startIndex, Index endIndex);


  /*************************** OVERRIDEN FROM TNLP ***********************/
  /** default destructor */
  virtual ~SubProblem();

  /** Method to return some info about the nlp */
  virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
                            Index& nnz_h_lag, IndexStyleEnum& index_style);

  /** Method to return the bounds for my problem */
  virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
                               Index m, Number* g_l, Number* g_u);

  /** Method to return the starting point for the algorithm */
  virtual bool get_starting_point(Index n, bool init_x, Number* x,
                                  bool init_z, Number* z_L, Number* z_U,
                                  Index m, bool init_lambda,
                                  Number* lambda);

  /** Method to return the objective value */
  virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);

  /** Method to return the gradient of the objective */
  virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);

  /** Method to return the constraint residuals */
  virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);

  /** Method to return:
   *   1) The structure of the jacobian (if "values" is NULL)
   *   2) The values of the jacobian (if "values" is not NULL)
   */
  virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
                          Index m, Index nele_jac, Index* iRow, Index *jCol,
                          Number* values);

  /** Method to return:
   *   1) The structure of the hessian of the lagrangian (if "values" is NULL)
   *   2) The values of the hessian of the lagrangian (if "values" is not NULL)
   */
  virtual bool eval_h(Index n, const Number* x, bool new_x,
                      Number obj_factor, Index m, const Number* lambda,
                      bool new_lambda, Index nele_hess, Index* iRow,
                      Index* jCol, Number* values);

  /** This method is called when the algorithm is complete so the TNLP can store/write the solution */
  virtual void finalize_solution(SolverReturn status,
                                 Index n, const Number* x, const Number* z_L, const Number* z_U,
                                 Index m, const Number* g, const Number* lambda,
                                 Number obj_value IPOPT8_FINARGS);



  /************************ SPECIFIC FUNCIONS *******************************/
  ApplicationReturnStatus solve();
  Number *xOrgSpace;

private:
  //declare proxy so compiler won't automatically generate this
  SubProblem(const SubProblem&);
  SubProblem& operator=(const SubProblem&);

  inline void computeNewArg(const Number *x);

  bool allocStructures();
  void deallocStructures();

  //dimension of the original problem
  Index originalDim;

  //dimension of this problem (optimizing subspace)
  Index subspaceDim;

  //original problem to solve
  AlgorithmRef algEngine;

  //indexes of variables which get optimized in this problem, endIndex is next after last
  Index startIndex;
  Index endIndex;

  //processors count
  Index procCount;

  //processor index
  Index procIndex;

  //original function cache
  Number *funGradient;
  Number funValue;
  Number *orgJacob;

  //jakobiany
  Index subNnzJac;
  Index subOptNnzJac;
};

#endif /* SUBFUNC_HPP_ */
